<!--控制计划的检测管理要求-->
<template>
  <div style="margin: 0;padding: 0">
    <el-container>
      <!--页面表头设计-->
      <el-header style="height: 7vh">
        <el-link class="headMain" href="http://10.255.96.48:3404/">俄动力质量管理系统</el-link>
         <span class="center-text">频次检测管理/span>
      </el-header>
      <el-container>
        <el-aside width="200px">
          <UseTree :data1="TreeList" @TreeClick.passive="TreeClick" style="height: 96%"></UseTree>
        </el-aside>
        <el-container>
          <!--主题设计-->
          <el-main>
            <div>
              <el-tabs v-model="activeName" @tab-click="handleClick">
                <el-tab-pane label="检测项目管理" name="first">
                  <el-table
                      :data="tableData"
                      border
                      style="width: 100%" height="68vh">
                    <el-table-column
                        :prop="project"
                        label="检验项目"
                        width="180">
                    </el-table-column>
                    <el-table-column
                        :prop="requirement"
                        label="检验要求"
                        width="180">
                    </el-table-column>
                    <el-table-column
                        label="检测类型" v-slot:default="typeTesting">
                      <el-link v-if="languageS==='chinese'">{{typeTesting.row.typeTesting.split('/')[0]}}</el-link>
                      <el-link v-if="languageS==='english'">{{typeTesting.row.typeTesting.split('/')[1]}}</el-link>
                      <el-link v-if="languageS==='russian'">{{typeTesting.row.typeTesting.split('/')[2]}}</el-link>
                    </el-table-column>
                    <el-table-column
                        prop="standard"
                        label="标准值">
                    </el-table-column>
                    <el-table-column
                        prop="ceiling"
                        label="上公差">
                    </el-table-column>
                    <el-table-column
                        prop="lower"
                        label="下公差">
                    </el-table-column>
                    <el-table-column
                        prop="frequency"
                        label="检验频次">
                    </el-table-column>
                    <el-table-column
                        v-slot:default="department"
                        label="实施部门">
                      <el-link v-if="languageS==='chinese'">{{department.row.department.split('/')[0]}}</el-link>
                      <el-link v-if="languageS==='english'">{{department.row.department.split('/')[1]}}</el-link>
                      <el-link v-if="languageS==='russian'">{{department.row.department.split('/')[2]}}</el-link>
                    </el-table-column>
                    <el-table-column
                        prop="projectType"
                        label="项目类型">
                    </el-table-column>
                    <el-table-column
                        prop="controlTesting"
                        label="ID">
                    </el-table-column>
                    <el-table-column label="编辑" width="220px" v-slot:default="scope"
                    v-if="usePower===1">
                      <el-link type="primary" @click="handleEdit(scope,1)" v-if="tableData[0].id!==-1 || tableData.length>1">编辑&nbsp;&nbsp;</el-link>
                      <el-link type="primary" @click="handleEdit(scope,2)" v-if="tableData[0].id!==-1 || tableData.length>1">删除&nbsp;&nbsp;</el-link>
                      <el-link type="primary" @click="handleEdit(scope,3)" v-if="tableData[0].id!==-1 || tableData.length>1">向下插入&nbsp;&nbsp;</el-link>
                    </el-table-column>
                  </el-table>
                </el-tab-pane>
                <el-tab-pane label="检测数据录入" name="second"
                    v-if="usePower===1 || usePower===2">
                  <div class="container">
                    <div>
                      <span>发动机号/零部件号：</span>&nbsp;&nbsp;
                      <el-input style="width: 120px" v-model="workpieceInput" @change="workpieceChang"></el-input>&nbsp;&nbsp;
                      <span>检测日期：</span>&nbsp;&nbsp;
                      <template class="block">
                        <el-date-picker
                            v-model="valueDate"
                            align="right"
                            type="date"
                            format="yyyy - MM - dd "
                            placeholder="选择日期"
                            :picker-options="pickerOptions"
                            @change="dateChange">
                        </el-date-picker>
                      </template>&nbsp;&nbsp;
                      <span>检验员工号:</span>&nbsp;&nbsp;
                      <span>{{useId}}</span>
                    </div>
                    <div>
                      <el-button @click="valueDateSave">保存</el-button>
                    </div>

                  </div>
                  <el-table
                      :data="tableDataValueUse"
                      border
                      style="width: 100%;margin-top: 10px" height="61vh">
                    <el-table-column
                        :prop="project"
                        label="检验项目">
                    </el-table-column>
                    <el-table-column
                        :prop="requirement"
                        label="检验要求">
                    </el-table-column>
                    <el-table-column
                        label="工件号"
                        prop="workpiece"
                        width="140"
                        v-slot:default="scope">
                      <el-input v-model="tableDataValueUse[scope.$index].workpiece"></el-input>
                    </el-table-column>
                    <el-table-column
                        prop="frequency"
                        label="检验频次"
                        width="80">
                    </el-table-column>
                    <el-table-column
                        v-slot:default="department"
                        label="实施部门"
                        width="120">
                      <el-link v-if="languageS==='chinese'">{{department.row.department.split('/')[0]}}</el-link>
                      <el-link v-if="languageS==='english'">{{department.row.department.split('/')[1]}}</el-link>
                      <el-link v-if="languageS==='russian'">{{department.row.department.split('/')[2]}}</el-link>
                    </el-table-column>
                    <el-table-column
                        label="实测值"
                        width="100"
                        v-slot:default="scope">
                      <el-input v-model="tableDataValueUse[scope.$index].valueUse"
                                @input="handleBlur($event,scope.$index)"></el-input>
                    </el-table-column>
                    <el-table-column
                        label="判定"
                        width="80"
                        v-slot:default="scope">
                      <el-button type="danger" :style="getButtonStyle(scope.$index)" circle>{{tableDataValueUse[scope.$index].passUse}}</el-button>
                    </el-table-column>
                  </el-table>
                </el-tab-pane>
                <el-tab-pane label="趋势管理" name="third">
                  <div class="UploadContainer">
                    <div class="UploadS1">
                      <div class="UploadS3">
                        <!--放置图表区域-->
                        <div ref="myChart" class="LineDiv"></div>
                      </div>
                      <div class="button">
                        <el-button type="info" plain style="width: 110px;margin-top: 5px;margin-left: 1px;" :style="buttonAll" @click="chart('all')">所有数据</el-button>
                        <el-button type="info" plain style="width: 110px;margin-top: 5px;margin-left: 1px" :style="button500" @click="chart(500)">500组数据</el-button>
                        <el-button type="info" plain style="width: 110px;margin-top: 5px;margin-left: 1px" :style="button300" @click="chart(300)">300组数据</el-button>
                        <el-button type="info" plain style="width: 110px;margin-top: 5px;margin-left: 1px" :style="button125" @click="chart(125)">125组数据</el-button>
                        <el-button type="info" plain style="width: 110px;margin-top: 5px;margin-left: 1px" :style="button25" @click="chart(25)">25组数据</el-button>
                      </div>
                    </div>
                    <div class="UploadRow">
                      <div class="UploadS2">
                        直方图
                        <div ref="myChartBor" style="height: 29vh;width:25vw"></div>
                      </div>
                      <div class="UploadS2">
                        移动极差
                        <div ref="myChartLine" style="height: 29vh;width:25vw"></div>
                      </div>
                      <div class="UploadS2-2">
                        过程能力
                        <div style="margin-top: 10px;text-align: left">CPK:{{cpk}}</div>
                        <div style="margin-top: 10px;text-align: left">判异结果：</div>
                        <div style="margin-top: 10px;text-align: left">原则1：</div>
                        <div style="margin-top: 10px;text-align: left">原则2：</div>
                        <div style="margin-top: 10px;text-align: left">原则3：</div>
                        <div style="margin-top: 10px;text-align: left">原则4：</div>
                        <div style="margin-top: 10px;text-align: left">原则5：</div>
                        <div style="margin-top: 10px;text-align: left">原则6：</div>
                        <div style="margin-top: 10px;text-align: left">原则7：</div>
                      </div>
                      <div class="UploadS2-1">
                        <el-table
                            :data="tableDataValueUse"
                            border
                            style="width: 100%;margin-top: 10px" height="28vh"
                            @row-click="projectHandleRowClick">
                          <el-table-column
                              :prop="project"
                              label="检验项目">
                          </el-table-column>
                        </el-table>
                      </div>
                    </div>
                  </div>
                </el-tab-pane>
                <el-tab-pane label="管理中台" name="fourth">
                  <div style="display: flex;justify-content: space-between;margin: 10px">
                    <el-card style="flex: 1;margin-right: 10px;margin-left: 10px;height: 200px">
                      <div slot="header" style="display: table;content: '';">
                        <span style="float: left">设置今日生产信息：</span>
                        <el-link style="margin-left: 15px">模型结果生成</el-link>
                      </div>
                      <div style="text-align: left; height: 100px; overflow-y: auto;">
                        <div style="display: flex; align-items: center;">
                          <span>EB05机型：</span>
                          <el-input-number label="描述文字" style="width: 150px;"></el-input-number>
                        </div>
                        <div style="margin-top: 10px">
                          <span>EB35机型：</span>
                          <el-input-number label="描述文字" style="width: 150px;"></el-input-number>
                        </div>
                        <div style="margin-top: 10px">
                          <span>EN19机型：</span>
                          <el-input-number label="描述文字" style="width: 150px;"></el-input-number>
                        </div>
                      </div>
                    </el-card>
                    <el-card style="flex: 1;margin-right: 10px;margin-left: 10px;height: 200px">
                      <div slot="header" style="display: table;content: '';">
                        <span style="float: left">当日检测情况：</span>
                      </div>
                      <div style="margin-top: 8px;text-align: left">
                        当日需要检测数量：{{}}项
                      </div>
                      <div style="margin-top: 8px;text-align: left; color: #0269fa">
                        当日已完成数量：{{}}项
                      </div>
                      <div style="margin-top: 8px;text-align: left; color: red">
                        当日未完成数量：{{}}项
                      </div>
                    </el-card>
                    <el-card style="flex: 1;margin-right: 10px;margin-left: 10px;height: 200px">
                      <div slot="header" style="display: table;content: '';">
                        <span style="float: left">目前检测合格情况：</span>
                      </div>
                      <div style="margin-top: 8px;text-align: left">
                        当日已完成{{}}项：
                      </div>
                      <div style="margin-top: 8px;text-align: left; color: #0269fa">
                        合格{{}}项，**%；
                      </div>
                      <div style="margin-top: 8px;text-align: left; color: red">
                        不合格{{}}项，**%；
                      </div>
                    </el-card>
                    <el-card style="flex: 1;margin-right: 10px;margin-left: 10px;height: 200px">
                      <div slot="header" style="display: table;content: '';">
                        <span>目前预警情况：</span>
                      </div>
                      <div style="text-align: left;margin-top: 8px">
                        连续上升/下降{{}}项；
                      </div>
                      <div style="text-align: left;margin-top: 8px;color: red">
                        预判过程能力变差{{}}项；
                      </div>
                      <div style="text-align: left;margin-top: 8px;color: #0269fa">
                        预判过程能力变好{{}}项；
                      </div>
                    </el-card>
                  </div>
                  <div style="margin: 10px">
                    <el-card style="flex: 1;margin-right: 10px;margin-left: 10px;height: 36vh">
                      <div slot="header" style="display: table;content: '';">
                        <span style="float: left">管理模型建议：</span>
                      </div>
                      <div style="margin-top: 8px;text-align: left">
                        {{suggestAi[0]}}
                      </div>
                      <div style="margin-top: 8px;text-align: left">
                        {{suggestAi[1]}}
                      </div>
                      <div style="margin-top: 8px;text-align: left">
                        {{suggestAi[2]}}
                      </div>
                      <div style="margin-top: 8px;text-align: left">
                        {{suggestAi[3]}}
                      </div>
                    </el-card>
                  </div>

                </el-tab-pane>
                <el-tab-pane label="数据管理" name="fifth"
                  v-if="usePower===1">
                  <el-table
                      :data="tableDataValueEdit"
                      border
                      style="width: 100%" height="68vh">
                    <el-table-column
                        :prop="project"
                        label="检验项目"
                        width="180">
                    </el-table-column>
                    <el-table-column
                        :prop="requirement"
                        label="检验要求"
                        width="180">
                    </el-table-column>
                    <el-table-column
                        prop="standard"
                        label="标准值"
                        width="70px">
                    </el-table-column>
                    <el-table-column
                        prop="ceiling"
                        label="上公差"
                        width="70px">
                    </el-table-column>
                    <el-table-column
                        prop="lower"
                        label="下公差"
                        width="70px">
                    </el-table-column>
                    <el-table-column
                        prop="testingDate"
                        label="检测日期"
                        v-slot:default="scope">
                      {{scope.row.testingDate}}
                      <el-link style="text-align: right">
                        <i class="el-icon-edit" @click="testingEdit(scope,1)"></i>
                      </el-link>
                    </el-table-column>
                    <el-table-column
                        prop="workpiece"
                        label="工件号"
                        v-slot:default="scope">
                      {{scope.row.workpiece}}
                      <el-link style="text-align: right">
                        <i class="el-icon-edit" @click="testingEdit(scope,2)"></i>
                      </el-link>
                    </el-table-column>
                    <el-table-column
                        prop="userId"
                        label="检测人员">
                    </el-table-column>
                    <el-table-column
                        prop="valueUse"
                        label="实测值"
                        v-slot:default="scope">
                      {{scope.row.valueUse}}
                      <el-link style="text-align: right">
                        <i class="el-icon-edit" @click="testingEdit(scope,3)"></i>
                      </el-link>
                    </el-table-column>
                  </el-table>
                </el-tab-pane>
                <el-tab-pane label="模型说明" name="sixth">
                </el-tab-pane>
              </el-tabs>

            </div>
          </el-main>
          <el-footer>
            <el-button plain size="small" @click="languageSelectChinese">中  文</el-button>
            <el-button plain size="small" @click="languageSelectRussian">Русский язык</el-button>
            <el-button plain size="small" @click="languageSelectEnglish">English</el-button>
          </el-footer>
        </el-container>
      </el-container>
    </el-container>

    <!--弹窗放置区-->
        <!--“列表编辑”弹窗-->
        <el-dialog
        :title="titleMessage"
        :visible.sync="dialogVisibleTesting"
        width="30%"
        :before-close="handleClose">
      <div>
        <el-form ref="tableDataTemp" :model="tableDataTemp" status-icon :rules="rules"  label-width="90px" :inline="true">
          <div class="UploadS">
            <el-form-item label="检测项目" class="item" prop="project">
              <el-input v-model="tableDataTemp.project" placeholder="检测项目" style="width: 120%" :disabled="doe===2"></el-input>
            </el-form-item>
            <el-form-item label="English" class="item" prop="projectEnglish">
              <el-input  v-model="tableDataTemp.projectEnglish" placeholder="检测项目" style="width: 120%" :disabled="doe===2"></el-input>
            </el-form-item>
            <el-form-item label="Russian" class="item" prop="projectRussian">
              <el-input  v-model="tableDataTemp.projectRussian" placeholder="检测项目" style="width: 120%" :disabled="doe===2"></el-input>
            </el-form-item>
          </div>

          <div class="UploadS">
            <el-form-item label="检测要求" class="item" prop="requirement">
              <el-input v-model="tableDataTemp.requirement" placeholder="检测项目" style="width: 120%" :disabled="doe===2"></el-input>
            </el-form-item>
            <el-form-item label="English" class="item" prop="requirementEnglish">
              <el-input  v-model="tableDataTemp.requirementEnglish" placeholder="检测项目" style="width: 120%" :disabled="doe===2"></el-input>
            </el-form-item>
            <el-form-item label="Russian" class="item" prop="requirementRussian">
              <el-input  v-model="tableDataTemp.requirementRussian" placeholder="检测项目" style="width: 120%" :disabled="doe===2"></el-input>
            </el-form-item>
          </div>

          <div class="UploadS">
            <el-form-item label="检测类型" class="item">
              <el-select v-model="tableDataTemp.typeTesting" placeholder="请选择" :disabled="doe===2">
                <el-option
                    v-for="item in options"
                    :key="item.value"
                    :label="item.label"
                    :value="item.value">
                </el-option>
              </el-select>
            </el-form-item>
            <el-form-item label="标准值" prop="standard" class="item">
              <el-input v-model="tableDataTemp.standard" placeholder="请输入标准值" :disabled="tableDataTemp.typeTesting==='目视/visual/Визуальное зрение' || tableDataTemp.typeTesting==='计数/count/Количество'||doe===2 || tableDataTemp.typeTesting===''"></el-input>
            </el-form-item>
            <el-form-item label="上偏差" prop="ceiling" class="item">
              <el-input v-model="tableDataTemp.ceiling" placeholder="请输入上偏差" :disabled="tableDataTemp.typeTesting==='目视/visual/Визуальное зрение' || tableDataTemp.typeTesting==='计数/count/Количество'||doe===2 || tableDataTemp.typeTesting===''"></el-input>
            </el-form-item>
            <el-form-item label="下偏差" prop="lower" class="item">
              <el-input v-model="tableDataTemp.lower" placeholder="请输入下偏差" :disabled="tableData.typeTesting==='目视/visual/Визуальное зрение' || tableData.typeTesting==='计数/count/Количество'||doe===2"></el-input>
            </el-form-item>
          </div>

          <div class="UploadS">
            <el-form-item label="检验频次%" prop="frequency" class="item">
              <el-input-number  v-model="tableDataTemp.frequency" :disabled="doe===2"></el-input-number><span>%</span>
            </el-form-item>
            <el-form-item label="责任部门" prop="department" class="item">
              <el-select v-model="tableDataTemp.department" placeholder="请选择" :disabled="doe===2">
                <el-option
                    v-for="item in optionsD"
                    :key="item.value"
                    :label="item.label"
                    :value="item.value">
                </el-option>
              </el-select>
            </el-form-item>
          </div>
          <br><br>
          <el-form-item>
            <el-button type="primary" @click="submitForm('tableDataTemp')">提交</el-button>
            <el-button @click="resetForm('tableData')" :disabled="doe===2">重置</el-button>
          </el-form-item>
        </el-form>
      </div>
    </el-dialog>
    <!--单击问题编辑区的弹窗，需要一个输入文本日期的地方-->
        <el-dialog
        :title="titleUse"
        :visible.sync="dialogVisibleDate"
        width="30%"
        :before-close="handleClose">
      <el-date-picker
          v-model="valueDate"
          type="date"
          placeholder="选择日期">
      </el-date-picker>
      <span slot="footer" class="dialog-footer">
    <el-button @click="dialogVisibleDate = false">取 消</el-button>
    <el-button type="primary" @click="saveTestingEdit">确 定</el-button>
  </span>
    </el-dialog>
    <!--单击问题编辑区的弹窗，需要一个输入文本地方-->
        <el-dialog
        :title="titleUse"
        :visible.sync="dialogVisibleName"
        width="30%"
        :before-close="handleClose">
      <el-input placeholder="请输入内容" v-model="inputName" style="width: 100%"></el-input>
      <span slot="footer" class="dialog-footer">
    <el-button @click="dialogVisibleName = false">取 消</el-button>
    <el-button type="primary" @click="saveTestingEdit">确 定</el-button>
  </span>
    </el-dialog>

  </div>
</template>

<script>
import UseTree from "@/components/utils/UseTree.vue";
import * as echarts from "echarts"

export default {
  name: "controlTestingNewO",
  components:{
    UseTree,

  },
  data(){
  //校验标准值，必须为数字，且不能为空
    var valStandard = (rule, value, callback) => {
      if (value === '' || value === null || value === undefined) {
        const regex = /^[-+]?\d+(\.\d+)?$/;
        if (!regex.test(value)) {
          callback(new Error('请输入有效的数字'));
        }
      } else {
        callback(); // 如果值有效（包括0），则通过校验
      }
    };
    //上偏差，必须为数字，且不能为空
    var valCeiling = (rule, value, callback) => {
      if (value === '' || value === null || value === undefined) {
        const regex = /^[-+]?\d+(\.\d+)?$/;
        if (!regex.test(value)) {
          callback(new Error('请输入有效的数字'));
        }
      } else {
        callback(); // 如果值有效（包括0），则通过校验
      }
    };
    //下偏差，必须为数字，且不能为空
    var valLower = (rule, value, callback) => {
      if (value === '' || value === null || value === undefined) {
        const regex = /^[-+]?\d+(\.\d+)?$/;
        if (!regex.test(value)) {
          callback(new Error('请输入有效的数字'));
        }
      } else {
        callback(); // 如果值有效（包括0），则通过校验
      }
    };
    //验证是否为空
    var valVoid = (rule, value, callback) => {
      if (!value) {
        return callback(new Error('请输入内容'));
      } else {
        callback(); // 如果值有效（包括0），则通过校验
      }
    };
    var valFrequency = (rule, value, callback) => {
      if (value === '' || value === null || value === undefined) {
        const regex = /^[-+]?\d+(\.\d+)?$/;
        if (!regex.test(value)) {
          callback(new Error('请输入有效的数字'));
        }
      } else if (value>100 ||value===0){
        callback(new Error('请输入小于100的数值或非0值'))
      }else {
        callback(); // 如果值有效（包括0），则通过校验
      }
    };
    return{
      //控制按钮样式
      buttonAll:'',
      button500:'',
      button300:'',
      button125:'',
      button25:'',
      //控制时间空间的函数
      pickerOptions: {
        disabledDate(time) {
          return time.getTime() > Date.now();
        },
        shortcuts: [{
          text: '今天',
          onClick(picker) {
            picker.$emit('pick', new Date());
          }
        }, {
          text: '昨天',
          onClick(picker) {
            const date = new Date();
            date.setTime(date.getTime() - 3600 * 1000 * 24);
            picker.$emit('pick', date);
          }
        }, {
          text: '一周前',
          onClick(picker) {
            const date = new Date();
            date.setTime(date.getTime() - 3600 * 1000 * 24 * 7);
            picker.$emit('pick', date);
          }
        }]
      },
      /*弹窗需要的变量*/
      //弹窗显示的信息
      titleMessage:'',

      //控制“编辑”弹窗
      dialogVisibleTesting:false,
      //控制修改数据中的修改日期的弹窗
      dialogVisibleDate:false,
      //控制修改数据中的修改文本类的
      dialogVisibleName:false,
      //需要修改的文本的用户输入的变量
      inputName:'',
      //弹窗的标题
      titleUse:'',
      //用户要选择修改行的Id
      testingEditUseId:-1,
      //用户修改数据，
      tableIndex:-1,
      //记录修正数据，用户选择的是那个操作
      useDoe:-1,

      //记录用户选择的是那种操作方式，编辑1，删除为2，向上插入为3，向下插入为4.
      doe:0,
      //返回用户选择数据的index。
      selectedIndexUse:0,
      /*用在aside的变量数据*/
      //记录页面呈现的导航信息
      TreeList:[],
      //记录后台返回的三种语言的导航信息
      TreeListAll:[],
      //点击导航栏，用到的变量
      ChildrenLabel:'no',
      parentLabel:'no',
      parentParentLable:'no',
      //记录用户选择的语言，默认为中文
      languageS:"chinese",
      /*三种语言的选择项目*/
      //记录导航中的三种语言的车间名称
      workshopEnglish:'',
      workshopChinese:'',
      workshopRussian:'',
      project:'project',
      //记录检验要求
      requirement:'requirement',
      //分页标签用的指定和判别分页的变量
      activeName: 'second',


      //用户输入的工件号
      workpieceInput:'',

      //记录用户选择的检测时间
      valueDate:'',
      valueDateUse:'',

      //列表需要展现的数据，筛选出的是“频次检测”检测项目，员工填入的列表中的所有的数据
      tableData: [{
        //主键
        id:-1,
        //车间名称（中文）
        workshop:'',
        //车间名称（英文）
        workshopEnglish:'',
        //车间名称（俄文）
        workshopRussian:'',
        //图号
        drawing:'',
        //工序号
        op:'',
        //记录检验项目
        project:'',
        //记录检验项目（英文）
        projectEnglish:'',
        //记录检验项目（俄文）
        projectRussian:'',
        //记录检验要求
        requirement:'',
        //记录检验要求（英文）
        requirementEnglish:'',
        //记录检验要求（俄文）
        requirementRussian:'',
        //记录检测类型
        typeTesting:'',
        //记录标准值
        standard:'',
        //记录上偏差
        ceiling:'',
        //记录下偏差
        lower:'',
        //frequency
        frequency:'',
        //记录实施部门
        department:'',
        //记录实施部门（英文）
        departmentEnglish:'',
        //记录实施部门（俄文）
        departmentRussian:'',
        //项目类型（1：代表控制计划项目，2：代表自行识别项目，3：代表控制计划加严项目）
        projectType:'',
        //关联控制计划的标记位
        controlTesting:'',
        //删除标记位（1：正常，0：删除）
        deleteSign:1,
        //记录顺序号
        orderNumber:0,
        //记录用户的实测值
        valueUse:'',
        //判断是否合格
        //控制显示判定是否合格的变量(0:没有参数，1：合格；2：不合格；3：超出控制线
        passUse:0,
        //检验员工号
        userId:'',
        //检测日期
        testingDate:'null',
        //检测的工件号
        workpiece:'null',
      },],
      //编辑数据表单的变量
      tableDataTemp: {
        //主键
        id:-1,
        //车间名称（中文）
        workshop:'',
        //车间名称（英文）
        workshopEnglish:'',
        //车间名称（俄文）
        workshopRussian:'',
        //图号
        drawing:'',
        //工序号
        op:'',
        //记录检验项目
        project:'',
        //记录检验项目（英文）
        projectEnglish:'',
        //记录检验项目（俄文）
        projectRussian:'',
        //记录检验要求
        requirement:'',
        //记录检验要求（英文）
        requirementEnglish:'',
        //记录检验要求（俄文）
        requirementRussian:'',
        //记录检测类型
        typeTesting:'',
        //记录标准值
        standard:'',
        //记录上偏差
        ceiling:'',
        //记录下偏差
        lower:'',
        //frequency
        frequency:'',
        //记录实施部门
        department:'',
        //记录实施部门（英文）
        departmentEnglish:'',
        //记录实施部门（俄文）
        departmentRussian:'',
        //项目类型（1：代表控制计划项目，2：代表自行识别项目，3：代表控制计划加严项目）
        projectType:'',
        //关联控制计划的标记位
        controlTesting:'',
        //删除标记位（1：正常，0：删除）
        deleteSign:1,
        //记录顺序号
        orderNumber:0,
        //记录用户的实测值
        valueUse:'',
        //判断是否合格
        //控制显示判定是否合格的变量(0:没有参数，1：合格；2：不合格；3：超出控制线
        passUse:0,
        //检验员工号
        userId:'',
        //检测日期
        testingDate:'null',
        //检测的工件号
        workpiece:'null',
        //记录用户选择的要查询的数据量是多少
        selectNum:'',
      },
      //记录计量型的数据，用户录入检测数据用
      tableDataValueUse:[],
      //记录用户筛选出查看趋势图的数据，也用在了维护数据正确性的页面上
      tableDataValueEdit:[],
      //三种语言切换的变量
      //主键
      //车间名称（中文）
      workshop:'',
      //图号
      drawing:'',
      //工序号
      op:'',
      //记录实施部门
      department:'',
      //检测类型选择器
      options: [{
        value: '目视/visual/Визуальное зрение',
        label: '目视/visual/Визуальное зрение'
      }, {
        value: '计量/metering/Измерение',
        label: '计量/metering/Измерение'
      }, {
        value: '计数/count/Количество',
        label: '计数/count/Количество'
      }],
      optionsD: [{
        value: '品质管理科/Quality Management Department/Секция управления качеством',
        label: '品质管理科/Quality Management Department/Секция управления качеством'
      }, {
        value: '装配车间/Assembly workshop/сборочный цех',
        label: '装配车间/Assembly workshop/сборочный цех'
      }, {
        value: '机加车间/Machining workshop/Машиностроительный цех',
        label: '机加车间/Machining workshop/Машиностроительный цех'
      }, {
        value: '物流科/Logistics Department/Отдел логистики',
        label: '物流科/Logistics Department/Отдел логистики'
      }],
      //校验数据用的函数

      rules:{
        standard:[{validator: valStandard, trigger: 'blur'}],
        ceiling:[{validator: valCeiling, trigger: 'blur'}],
        lower:[{validator: valLower, trigger: 'blur'}],

        requirement:[{validator: valVoid, trigger: 'blur'}],
        requirementEnglish:[{validator: valVoid, trigger: 'blur'}],
        requirementRussian:[{validator: valVoid, trigger: 'blur'}],

        project:[{validator: valVoid, trigger: 'blur'}],
        projectEnglish:[{validator: valVoid, trigger: 'blur'}],
        projectRussian:[{validator: valVoid, trigger: 'blur'}],

        typeTesting:[{validator: valVoid, trigger: 'blur'}],
        department:[{validator: valVoid, trigger: 'blur'}],
        frequency:[{validator: valFrequency, trigger: 'blur'}],
      },
      /*图表需要的数据展现区域*/
      //记录用户想看的数据是多少组
      selectNum:25,
      tempDataX:[],
      tempDataS:[],
      tempDataSt:[],
      tempDataCe:[],
      tempDataLo:[],

      //Echarts实例设计到的函数
      //画趋势图
      chartUser: null, // 保存ECharts实例
      option: {
        title:{
          //设置标题的样式
          textStyle:{
            color:'red',
          },
          //设置标题的居中方式（水平）
          x:'center',
          text:'暂未选择',
        },
        xAxis:{
          data:[]
        },
        yAxis:{
          type: 'value',
          min:0, // 设置y轴的最小值
          max:100,//设置y轴的最大值
        },
        series:[{
          //设置系列，设置当前映射出的图形
          name:'valueUse',
          type:'line',
          stack:'num',
          data:[]
        },
          {
            //设置系列，设置当前映射出的图形
            name:'standard',
            type:'line',
            stack:'standard',
            data:[]
          },
          {
            //设置系列，设置当前映射出的图形
            name:'ceiling',
            type:'line',
            stack:'ceiling',
            data:[]
          },
          {
            //设置系列，设置当前映射出的图形
            name:'lower',
            type:'line',
            stack:'lower',
            data:[]
          },],
        grid: {
          top:'8%',
          left: '2%', // 图表内容距离容器左侧的距离
          right: '2%', // 图表内容距离容器右侧的距离
          bottom: '10%', // 图表内容距离容器底部的距离，可以适当增加这个值来留出更多空间给标题
          containLabel: true, // 网格是否包含坐标轴的标签在内
        },
        tooltip:{
          //触发类型
          trigger:'axis',
          //设置坐标轴的指示器
          axisPointer:{
            type: 'cross'
          },
        },
      },
      //画直方图
      chartUserBor:null,
      optionBor: {
        tooltip: {
          trigger: 'axis',
          axisPointer: {
            type: 'shadow'
          }
        },
        grid: {
          top:'3%',
          left: '3%',
          right: '4%',
          bottom: '10%',
          containLabel: true
        },
        xAxis: [
          {
            type: 'category',
            data: ['1/10', '2/10', '3/10', '4/10', '5/10', '6/10','7/10','8/10','9/10','10/10'],
            axisTick: {
              alignWithLabel: true
            }
          }
        ],
        yAxis: [
          {
            type: 'value'
          }
        ],
        series: [
          {
            name: 'Direct',
            type: 'bar',
            barWidth: '60%',
            data:[]
          }
        ]
      },
      //画移动极差图
      chartUserLien:null,
      optionLien: {
        title:{
          //设置标题的样式
          textStyle:{
            color:'red',
          },
          //设置标题的居中方式（水平）
          x:'center',
        },
        xAxis:{
          data:[]
        },
        yAxis:{
          type: 'value',
          min:0, // 设置y轴的最小值
          max:100,//设置y轴的最大值
        },
        series:[{
          //设置系列，设置当前映射出的图形
          name:'valueUse',
          type:'line',
          stack:'num',
          data:[]
        },
          {
            //设置系列，设置当前映射出的图形
            name:'standard',
            type:'line',
            stack:'standard',
            data:[]
          },
          {
            //设置系列，设置当前映射出的图形
            name:'ceiling',
            type:'line',
            stack:'ceiling',
            data:[]
          },
          {
            //设置系列，设置当前映射出的图形
            name:'lower',
            type:'line',
            stack:'lower',
            data:[]
          },],
        grid: {
          top:'8%',
          left: '2%', // 图表内容距离容器左侧的距离
          right: '2%', // 图表内容距离容器右侧的距离
          bottom: '10%', // 图表内容距离容器底部的距离，可以适当增加这个值来留出更多空间给标题
          containLabel: true, // 网格是否包含坐标轴的标签在内
        },
        tooltip:{
          //触发类型
          trigger:'axis',
          //设置坐标轴的指示器
          axisPointer:{
            type: 'cross'
          },
        },
      },

      //过程能力相关的项目
      cpk:0,

      //用户权限相关的变量
      useName:'',//用户名称
      useId:'',//用户编号
      usePower:'',//用户权限 1.最高权限，所有的内容都可以操作；2.可以作为数据录入；其他：只能观看

      //管理模型建议数组
      suggestAi:[
        '管理建议1：请将您的判断条件与数据分析工程师说明，更新系统后可自动运行；',
        '管理建议2：30天内，*****个特性（点击查看）过程能力变差，请品质管理人员识别是否需要立项；',
        '管理建议3：90天内，*****个特性（点击查看）过程能力变差，请品质管理人员识别是否需要立项；',
        '管理建议4：30天内，*****个特性（点击查看）过程能力突变，请品质管理人员识别是否需要立项；',
        '管理建议5：请将您的判断条件与数据分析工程师说明，更新系统后可自动运行；',
        '管理建议6：30天内，*****个特性（点击查看）过程能力变差，请品质管理人员识别是否需要立项；',
        '管理建议7：90天内，*****个特性（点击查看）过程能力变差，请品质管理人员识别是否需要立项；',
        '管理建议8：30天内，*****个特性（点击查看）过程能力突变，请品质管理人员识别是否需要立项；'
      ],

    }
  },
  watch:{

  },
  methods:{
    //当时间变化的时候
    dateChange(){
      //判断有没有数据，没有数据不让选择时间，提示选择工序
      if (this.ChildrenLabel==='no' || this.tableDataValueUse.length===0){
        alert("您未选择工序，或无检测项目，请核对后进行操作")
        this.valueDate=''
        this.valueDateUse=''
      }else {
        const date = new Date(this.valueDate);
        const year = date.getFullYear().toString().padStart(4, '0');
        const month = (date.getMonth() + 1).toString().padStart(2, '0'); // 月份从0开始，所以需要+1
        const day = date.getDate().toString().padStart(2, '0');
        this.valueDateUse=`${year}-${month}-${day}`
      }
      for (let i = 0; i < this.tableDataValueUse.length; i++) {
        this.tableDataValueUse[i].testingDate=this.valueDateUse
      }
    },
    //当用户输入的工件号有改变的时候
    workpieceChang(){
      if (this.ChildrenLabel==='no'){
        alert("请选择工序后开始编辑")
        this.workpieceInput=''
      }
      let temp=this.tableDataValueUse
      this.tableDataValueUse=[]
      for (let i = 0; i < temp.length; i++) {
        this.$set(temp[i], 'workpiece', this.workpieceInput);
      }
      this.tableDataValueUse=temp
    },
    //监控输入
    handleBlur(value,valueUse) {
      // 这里你可以访问到 event 对象，以及通过 this 访问到 Vue 实例的属性和方法
      let passMin=value-(this.tableDataValueUse[valueUse].standard+this.tableDataValueUse[valueUse].lower)
      let passMax=this.tableDataValueUse[valueUse].standard+this.tableDataValueUse[valueUse].ceiling-value
      if (passMax>=0 && passMin>=0){
        this.tableDataValueUse[valueUse].passUse=1
      }else if (passMin<0 || passMax<0){
        this.tableDataValueUse[valueUse].passUse=2
      }else {
        this.tableDataValueUse[valueUse].passUse=0
      }
    },
    //设置判定的颜色
    getButtonStyle(index) {
      const passUse = this.tableDataValueUse[index].passUse;
      let style = { backgroundColor: 'black' }; // 默认样式
      if (passUse === 1) {
        style.backgroundColor = 'royalblue';
      } else if (passUse === 2) {
        style.backgroundColor = 'red';
      } else if (passUse === 3) {
        // 设置其他颜色...
      } else if (passUse===0){
        style.backgroundColor = 'black';
      }
      return style;
    },
    //当选择语言为中文时
    languageSelectChinese(){
      this.languageS="chinese"
      this.TreeList=this.TreeListAll.slice(this.TreeListAll.length/3,this.TreeListAll.length/3*2)
      this.project='project'
      this.requirement='requirement'
    },
    //当选择语言为俄文时
    languageSelectRussian(){
      this.languageS="russian"
      this.TreeList=this.TreeListAll.slice(this.TreeListAll.length/3*2,this.TreeListAll.length)
      this.project='projectRussian'
      this.requirement='requirementRussian'
    },
    //当选择语言为英语时
    languageSelectEnglish(){
      this.languageS="english"
      this.TreeList=this.TreeListAll.slice(0,this.TreeListAll.length/3)
      this.project='projectEnglish'
      this.requirement='requirementEnglish'
    },
    //点击分页表头的函数
    handleClick(tab, event) {
      console.log(tab, event);
      if (tab.label==='检测数据录入'){
        for (let i = 0; i < this.tableDataValueUse.length; i++) {
          this.tableDataValueUse[i].valueUse=''
        }
      }
    },
    //点击导航的函数
    TreeClick(data,node){
      //判断点击的字符有没有“OP”,如果有，说明已经点击到了第三层，可以进行赋值了，如果没有，把父级的设置为“no”
      if (data.label.includes("OP")){
        const parentNode=node.parent
        this.ChildrenLabel=data.label
        this.parentLabel=parentNode.label
        this.parentParentLable=node.parent.parent.label
        /*向后端发送请求，筛选出对应工序的类别*/
        //需要传输3个参数，一个是工序号，一个是产品图号，一个是车间名称，涉及到3个语言的，统一传递英文内容,本次请求，只涉及到车间名称是需要查询因为的；
        //新建一个变量，记录英文的车间名称
        let workshopS=''
        //新建一个变量，记录所有的三种语言的名称
        let workshopAll=[]
        //记录索引值
        let index
        for (let i = 0; i < this.TreeListAll.length; i++) {
          workshopAll.push(this.TreeListAll[i].label)
        }
        //找到现在车间名称在整个车间名称中的位置
        index=workshopAll.indexOf(node.parent.parent.label)
        if (index!==-1){
          if (this.languageS==='english') {
            workshopS = node.parent.parent.label
            this.workshopEnglish = workshopS
            this.workshopChinese = workshopAll[index + workshopAll.length / 3]
            this.workshopRussian = workshopAll[index + workshopAll.length / 3 * 2]
          }
          else if (this.languageS==='chinese'){
            if (index!==-1){
              //中文的目录排在中间，需要向上去找英文的名称，找到的索引减去1/3的整个车间长度即为对应的车间名称
              this.workshopEnglish=workshopAll[index-workshopAll.length/3]
              this.workshopChinese=workshopAll[index]
              this.workshopRussian=workshopAll[index+workshopAll.length/3]
            }else {
              alert("程序有异常，请联系管理员")
            }
          }
          else if (this.languageS==='russian'){
            //中文的目录排在中间，需要向上去找英文的名称，找到的索引减去2/3的整个车间长度即为对应的车间名称
              this.workshopEnglish=workshopAll[index-(workshopAll.length/3*2)]
              this.workshopChinese=workshopAll[index-workshopAll.length/3]
              this.workshopRussian=workshopAll[index]
          }
        } else {
          alert("程序出现错误，请联系管理员")
          return
        }

        //把导航中的“OP”去掉，给后端传递数据
        let numberStr = this.ChildrenLabel.slice(2)
        //向后端发送请求，发三个参数
        this.$request.post('/controlTestingList',{
          op:numberStr,
          drawing:this.parentLabel,
          workshopEnglish:this.workshopEnglish,
        }).then(result=>{
          this.tableData=result.data
          this.tableDataValueUse=[]
          for (let i = 0; i < this.tableData.length; i++) {
            //添加主表缺少的检验人员信息
            this.tableData[i].userId=this.useId
            //添加主表缺少的检测日期信息
            this.tableData[i].testingDate='null'
            this.tableData[i].workpiece='null'
            //添加主表缺少的检测工件号信息
            if (this.tableData[i].typeTesting==='计量/metering/Измерение'){
              this.tableDataValueUse.push(this.tableData[i])
              this.workpieceInput=''
              this.valueDate=''
              this.valueDateUse=''
            }
          }
        })
      }else {
        this.parentParentLable='no'
        this.parentLabel='no'
        this.ChildrenLabel='no'
      }

    },
    //点击行的"编辑"时候，进行赋值
    handleEdit(scope,doe){
      if (this.ChildrenLabel==='no'||this.parentLabel==='no'){
        alert("请选择工序")
        return
      }
      if (doe===1){
        //编辑操作
        this.titleMessage="您正在进行《编辑》操作"
        this.tableDataTemp=scope.row
      }
      else if (doe===2){
        //删除操作
        this.titleMessage="您正在进行《删除》操作"
        //赋值元数据，删除的时候只修改删除标记位
        this.tableDataTemp=scope.row
        //设置输入功能不可用。
      }
      else if (doe===3){
        this.tableDataTemp={
          //主键
          id:-1,
          //车间名称（中文）
          workshop:'',
          //车间名称（英文）
          workshopEnglish:'',
          //车间名称（俄文）
          workshopRussian:'',
          //图号
          drawing:'',
          //工序号
          op:'',
          //记录检验项目
          project:'',
          //记录检验项目（英文）
          projectEnglish:'',
          //记录检验项目（俄文）
          projectRussian:'',
          //记录检验要求
          requirement:'',
          //记录检验要求（英文）
          requirementEnglish:'',
          //记录检验要求（俄文）
          requirementRussian:'',
          //记录检测类型(1:目视检查；2：计量型；3：计数型）
          typeTesting:'',
          //记录标准值
          standard:0,
          //记录上偏差
          ceiling:0,
          //记录下偏差
          lower:0,
          //frequency
          frequency:'',
          //记录实施部门
          department:'',
          //记录实施部门（英文）
          departmentEnglish:'',
          //记录实施部门（俄文）
          departmentRussian:'',
          //项目类型（1：代表控制计划项目，2：代表自行识别项目，3：代表控制计划加严项目）
          projectType:'',
          //关联控制计划的标记位
          controlTesting:-100,
          //删除标记位（1：正常，0：删除）
          deleteSign:1,
          //记录顺序号
          orderNumber:0,
        }
        this.titleMessage='您正在进行《向下插入》操作'
      }
      else if (doe===4){
        this.tableDataTemp={
          //主键
          id:-1,
          //车间名称（中文）
          workshop:'',
          //车间名称（英文）
          workshopEnglish:'',
          //车间名称（俄文）
          workshopRussian:'',
          //图号
          drawing:'',
          //工序号
          op:'',
          //记录检验项目
          project:'',
          //记录检验项目（英文）
          projectEnglish:'',
          //记录检验项目（俄文）
          projectRussian:'',
          //记录检验要求
          requirement:'',
          //记录检验要求（英文）
          requirementEnglish:'',
          //记录检验要求（俄文）
          requirementRussian:'',
          //记录检测类型(1:目视检查；2：计量型；3：计数型）
          typeTesting:'',
          //记录标准值
          standard:0,
          //记录上偏差
          ceiling:0,
          //记录下偏差
          lower:0,
          //frequency
          frequency:'',
          //记录实施部门
          department:'',
          //记录实施部门（英文）
          departmentEnglish:'',
          //记录实施部门（俄文）
          departmentRussian:'',
          //项目类型（1：代表控制计划项目，2：代表自行识别项目，3：代表控制计划加严项目）
          projectType:'',
          //关联控制计划的标记位
          controlTesting:-100,
          //删除标记位（1：正常，0：删除）
          deleteSign:1,
          //记录顺序号
          orderNumber:0,
        }
        this.titleMessage='您正在进行《向上插入》操作'
      }
      else if (doe===5){
        this.tableDataTemp={
          //主键
          id:-1,
          //车间名称（中文）
          workshop:'',
          //车间名称（英文）
          workshopEnglish:'',
          //车间名称（俄文）
          workshopRussian:'',
          //图号
          drawing:'',
          //工序号
          op:'',
          //记录检验项目
          project:'',
          //记录检验项目（英文）
          projectEnglish:'',
          //记录检验项目（俄文）
          projectRussian:'',
          //记录检验要求
          requirement:'',
          //记录检验要求（英文）
          requirementEnglish:'',
          //记录检验要求（俄文）
          requirementRussian:'',
          //记录检测类型(1:目视检查；2：计量型；3：计数型）
          typeTesting:'',
          //记录标准值
          standard:0,
          //记录上偏差
          ceiling:0,
          //记录下偏差
          lower:0,
          //frequency
          frequency:'',
          //记录实施部门
          department:'',
          //记录实施部门（英文）
          departmentEnglish:'',
          //记录实施部门（俄文）
          departmentRussian:'',
          //项目类型（1：代表控制计划项目，2：代表自行识别项目，3：代表控制计划加严项目）
          projectType:'',
          //关联控制计划的标记位
          controlTesting:-100,
          //删除标记位（1：正常，0：删除）
          deleteSign:1,
          //记录顺序号
          orderNumber:0,
        }
        this.titleMessage='您正在进行《空项目插入》操作'
      }
      //设置用户现在了什么操作
      this.doe=doe
      //返回用户选择数据的index。
      this.selectedIndexUse=scope.$index
      this.dialogVisibleTesting=true
    },
    //语言的判断过程
    handleClose(done) {
      this.$confirm('确认关闭？')
          .then(_ => {
            console.log(_)
            done();
          })
          .catch(_ => {
            console.log(_)
          });
    },
    //点击弹出的窗口“提交”按钮后的动作，向后端发送数据，进行保存
    submitForm(formName) {
      this.$refs[formName].validate((valid) => {
        if (valid) {
          //当点击编辑的时候触发的条件
          if (this.doe===1){
            //执行“编辑”编辑操作
            //向后端写数据
            //判断选择的检测类型，如果是计量型和计数型，对数据进行限定
            if (this.tableDataTemp.typeTesting==='目视/visual/Визуальное зрение' && this.tableDataTemp.typeTesting==='计数/count/Количество'){
              this.tableData.standard=0
              this.tableData.ceiling=0
              this.tableData.lower=0
            }

            this.tableDataTemp.projectType=2
            //3.对删除标记位进行赋值
            this.tableDataTemp.deleteSign=1
            //对部门进行赋值(没有开发）
            //向后端发送信息，保存数据
            this.$request.put('ControlTestingPut',this.tableDataTemp).then(result=>{
              if (result.code === 401){
                this.$router.push('UserLogin')
                alert("您未登录，请登录")
              }else {
                this.tableData=result.data
                alert("已经修改成功")
                this.dialogVisibleTesting=false;
              }
            })
          }
          else if (this.doe===2){
            //执行删除操作
            if (confirm("确定要删除吗？")){
              //设置标记位
              this.tableDataTemp.deleteSign=0
              //执行修改请求
              //向后端发送信息，保存数据
              this.$request.put('ControlTestingPut',this.tableDataTemp).then(result=>{
                if (result.code === 401){
                  this.$router.push('UserLogin')
                  alert("您未登录，请登录")
                }else {
                  this.tableData=result.data
                  alert("已经修改成功")
                  this.dialogVisibleTesting=false
                }
              })
            }else {this.dialogVisibleTesting=false}
          }
          else if (this.doe===3) {/*执行插入操作，所有的列表数据均需要修改*///把数据插入进去
            this.tableDataTemp.id = -1//把新数据的Id设置为-1，方便后端判断
            //编辑初始的数据
            //判断选择的检测类型，如果是计量型和计数型，对数据进行限定
            if (this.tableDataTemp.typeTesting === '目视/visual/Визуальное зрение' && this.tableDataTemp.typeTesting === '计数/count/Количество') {
              this.tableDataTemp.standard = 0
              this.tableDataTemp.ceiling = 0
              this.tableDataTemp.lower = 0
            }
            //1.对车间名称赋值\图号\工序号进行赋值
            this.tableDataTemp.workshop = this.workshopChinese
            this.tableDataTemp.workshopEnglish = this.workshopEnglish
            this.tableDataTemp.workshopRussian = this.workshopRussian
            this.tableDataTemp.drawing = this.parentLabel
            this.tableDataTemp.op = this.ChildrenLabel.slice(2)
            //3.对删除标记位进行赋值
            this.tableDataTemp.deleteSign = 1
            //对控制计划的项目进行标记
            this.tableDataTemp.controlTesting = -1
            //对类型进行设置
            this.tableDataTemp.typeTesting=2
            //对数据加入到队列中
            let Temp = this.tableData
            Temp.splice(this.selectedIndexUse + 1, 0, this.tableDataTemp)
            //重新排布顺序号,对检测类型为2（自行添加的）进行重新排号，不是的不进行编号
            //作为数组的编号变量
            let j=0;
            for (let i = 0; i < Temp.length; i++) {
              if (Temp[i].typeTesting===2){
                Temp[i].orderNumber = i
                i=j+1
              }
            }
            //向后端发送一个Post请求，修改数据
            this.$request.post("/controlTestingInsertList", Temp).then(result => {
              if (result.code === 401) {
                this.$router.push('UserLogin')
                alert("您未登录，请登录")
              } else {
                this.tableData = result.data
                alert("已经修改成功")
                this.dialogVisibleTesting = false;
              }
            })
          }
        } else {
          console.log('error submit!!');
          return false;
        }
      });
    },
    //点击弹窗中的“重置”按钮
    resetForm(formName) {
      this.$refs[formName].resetFields();
    },
    //点击“检测数据录入”的“保存”按钮的时候，对数据进行保存
    valueDateSave(){
      //把编辑过的数据筛选出来，对于检测值为空的值，去除
      let temp=[]
      for (let i = 0; i < this.tableDataValueUse.length; i++) {
        if (this.tableDataValueUse[i].valueUse!==''){
          temp.push(this.tableDataValueUse[i])
        }
      }
      if (temp.length===0){
        alert("无数据需要保存")
        return;
      }
      //校验数据，如果工件号没有，提示无工件号
      for (let i = 0; i < temp.length; i++) {
        if (temp[i].workpiece==='null'){
          alert("有“工件号”未填写，请检查")
          return
        }
        if (temp[i].testingDate==='null'){
          alert("有项目的检测时间未设置，请设置")
          return;
        }
      }
      //校验通过，向后端写数据
      this.$request.post('/testingValInsert',temp).then(result=>{
        if (result.code === 401){
          this.$router.push('UserLogin')
          alert("您未登录，请登录")
        }else {
          this.tableDataValueUse=[]
          alert("已经保存成功，如果还有录入需求，请再次点击工序")
        }
      })
    },
    //点击画图的数据，选择是多少组
    chart(nub){
      if (nub===25){
        this.selectNum=25
        this.button25={ backgroundColor: '#0269fa' }
        this.button125={}
        this.button300={}
        this.button500={}
        this.buttonAll={}

      }
      else if (nub===125){
        this.selectNum=125
        this.button25={}
        this.button125={ backgroundColor: '#0269fa' }
        this.button300={}
        this.button500={}
        this.buttonAll={}
      }
      else if (nub===300){
        this.selectNum=300
        this.button25={}
        this.button125={}
        this.button300={ backgroundColor: '#0269fa' }
        this.button500={}
        this.buttonAll={}
      }
      else if (nub===500){
        this.selectNum=500
        this.button25={}
        this.button125={}
        this.button300={}
        this.button500={ backgroundColor: '#0269fa' }
        this.buttonAll={}
      }
      else if (nub==='all'){
        this.selectNum=10000
        this.selectNum=500
        this.button25={}
        this.button125={}
        this.button300={}
        this.button500={}
        this.buttonAll={ backgroundColor: '#0269fa' }
      }
    },
    //画趋势图
    EchartLien(result){
      this.tempDataX=[]
      this.tempDataS=[]
      this.tempDataSt=[]
      this.tempDataLo=[]
      this.tempDataCe=[]
      //清空数据
      this.option.series[0].data=[]
      this.option.series[1].data=[]
      this.option.series[2].data=[]
      this.option.series[3].data=[]

      //组合图线的数据
      for (let i = 0; i < result.data.length; i++) {
        this.tempDataX.push(result.data[i].testingDate)
        this.tempDataS.push(result.data[i].valueUse)
        this.tempDataSt.push(result.data[i].standard)
        this.tempDataCe.push(result.data[i].standard+result.data[i].ceiling)
        this.tempDataLo.push(result.data[i].standard+result.data[i].lower)
      }
      this.option.xAxis.data=this.tempDataX
      this.option.series[0].data=this.tempDataS
      this.option.series[1].data=this.tempDataSt
      this.option.series[2].data=this.tempDataCe
      this.option.series[3].data=this.tempDataLo
      //设定y轴的最小值
      this.option.yAxis.min=result.data[0].standard+result.data[0].lower*2
      this.option.yAxis.max=result.data[0].standard+result.data[0].ceiling*2
      //组合到配置项中
      this.chartUser.setOption(this.option);
    },
    //画直方图
    EchartBor(result){
      this.tempDataX=['1/10','2/10','3/10','4/10','5/10','6/10','7/10','8/10','9/10','10/10']
      this.optionBor.series[0].data=[]
      this.optionBor.xAxis.data=this.tempDataX
      // 设定变量值
      let valueTemp=[0,0,0,0,0,0,0,0,0,0]
      //下线最小值
      let Cls=result.data[0].standard+result.data[0].lower
      let cL=result.data[0].ceiling-result.data[0].lower
      for (let i = 0; i < result.data.length; i++) {
        if ( result.data[i].valueUse>=Cls && result.data[i].valueUse<Cls+cL/10){
          valueTemp[0]=valueTemp[0]+1
        }
        else if (result.data[i].valueUse>=Cls+cL/10 && result.data[i].valueUse<Cls+cL/10*2){
          valueTemp[1]=valueTemp[1]+1
        }
        else if (result.data[i].valueUse>=Cls+cL/10*2 && result.data[i].valueUse<Cls+cL/10*3){
          valueTemp[2]=valueTemp[2]+1
        }
        else if (result.data[i].valueUse>=Cls+cL/10*3 && result.data[i].valueUse<Cls+cL/10*4){
          valueTemp[3]=valueTemp[3]+1
        }
        else if (result.data[i].valueUse>=Cls+cL/10*4 && result.data[i].valueUse<Cls+cL/10*5){
          valueTemp[4]=valueTemp[4]+1
        }
        else if (result.data[i].valueUse>=Cls+cL/10*5 && result.data[i].valueUse<Cls+cL/10*6){
          valueTemp[5]=valueTemp[5]+1
        }
        else if (result.data[i].valueUse>=Cls+cL/10*6 && result.data[i].valueUse<Cls+cL/10*7){
          valueTemp[6]=valueTemp[6]+1
        }
        else if (result.data[i].valueUse>=Cls+cL/10*7 && result.data[i].valueUse<Cls+cL/10*8){
          valueTemp[7]=valueTemp[7]+1
        }
        else if (result.data[i].valueUse>=Cls+cL/10*8 && result.data[i].valueUse<Cls+cL/10*9){
          valueTemp[8]=valueTemp[8]+1
        }
        else if (result.data[i].valueUse>=Cls+cL/10*9 && result.data[i].valueUse<Cls+cL/10*10){
          valueTemp[9]=valueTemp[9]+1
        }
      }
      //设定y轴的最小值
      this.optionBor.series[0].data=valueTemp
      //组合到配置项中
      this.chartUserBor.setOption(this.optionBor);
    },
    //画移动极差图
    EchartLienMove(result){
      this.tempDataX=[]
      this.tempDataS=[]
      this.tempDataSt=[]
      this.tempDataLo=[]
      this.tempDataCe=[]

      this.optionLien.series[0].data=[]
      this.optionLien.series[1].data=[]
      this.optionLien.series[2].data=[]
      this.optionLien.series[3].data=[]

      //建立一个空的数据，是数组，记录移动极差。
      let tempZ
      for (let i = 0; i < result.data.length-1; i++) {
        this.tempDataX.push(result.data[i].testingDate)
        tempZ=result.data[i].valueUse-result.data[i+1].valueUse
        this.tempDataS.push(tempZ)
        this.tempDataCe.push(result.data[i].ceiling)
        this.tempDataLo.push(result.data[i].lower)
      }
      this.optionLien.xAxis.data=this.tempDataX
      this.optionLien.series[0].data=this.tempDataS
      this.optionLien.series[1].data=this.tempDataSt
      this.optionLien.series[2].data=this.tempDataCe
      this.optionLien.series[3].data=this.tempDataLo
      //设定y轴的最小值
      this.optionLien.yAxis.min=result.data[0].lower*2
      this.optionLien.yAxis.max=result.data[0].ceiling*2
      //组合到配置项中
      this.chartUserLien.setOption(this.optionLien);
    },
    //计算标准方差
    calculateStandardDeviation(array) {
      // 计算数组长度
      var n = array.length;

      // 计算数组的平均值
      var sum = array.reduce((a, b) => a + b, 0);
      var avg = sum / n;

      // 计算每个数与平均值的差的平方和
      var sumOfSquares = array.reduce((acc, val) => acc + Math.pow(val - avg, 2), 0);

      // 计算标准差 并返回

      return Math.sqrt(sumOfSquares / (n - 1));
    },
    //计算CPK
    calculateCpk(array, USL, LSL) {
      // 计算平均值和标准差
      const avg = array.reduce((a, b) => a + b, 0) / array.length;
      const stdDev=this.calculateStandardDeviation(array);

      // 计算Cpk
      const upperCapability = (USL - avg) / (3 * stdDev);
      const lowerCapability = (avg - LSL) / (3 * stdDev);
      return Math.min(upperCapability, lowerCapability);
    },
    //在趋势管理中，点击需要查看的项目的时候
    projectHandleRowClick(row) {
      if (this.languageS==='chinese'){
        this.option.title.text=row.project
      }
      else if (this.languageS==='english'){
        this.option.title.text=row.projectEnglish
      }
      else if (this.languageS==='russian'){
        this.option.title.text=row.projectRussian
      }
      //向后端发送请求，筛选数据
        this.tableDataTemp=row
        this.tableDataTemp.selectNum=this.selectNum

        //向后端发送请求，筛选出需要的组数据
        this.$request.post("/selectNum",this.tableDataTemp).then(result=>{
          //判断，如果登录异常，跳转到登录页面
          if (result.code === 401) {
            this.$router.push('UserLogin')
            alert("您未登录，请登录")
          }
          else {
            if (this.chartUser) {
              this.chartUser.dispose()
            }
            if (this.chartUserBor){
              this.chartUserBor.dispose()
            }
            if (this.chartUserLien){
              this.chartUserLien.dispose()
            }
            // 画图用到的，画趋势图
            //清空数据
            this.option.series[0].data=[]
            this.option.series[1].data=[]
            this.option.series[2].data=[]
            this.option.series[3].data=[]
            this.chartUser= echarts.init(this.$refs.myChart)
            this.chartUser.setOption(this.option);
            //画直方图
            //清空数据
            this.optionBor.series[0].data=[]
            this.chartUserBor=echarts.init(this.$refs.myChartBor)
            this.chartUserBor.setOption(this.optionBor)
            //画移动极差图
            //清空数据
            this.optionLien.series[0].data=[]
            this.optionLien.series[1].data=[]
            this.optionLien.series[2].data=[]
            this.optionLien.series[3].data=[]

            this.chartUserLien=echarts.init(this.$refs.myChartLine)
            this.chartUserLien.setOption(this.optionLien)

            if (result.data.length>1){
              //画趋势图
              this.EchartLien(result)
              //画直方图
              this.EchartBor(result)
              //画移动极差图
              this.EchartLienMove(result)
              //计算过程能力CPK
              this.cpk=-this.calculateCpk(this.tempDataS,result.data[0].standard+result.data[0].ceiling,result.data[0].standard+result.data[0].lower).toFixed(2)
              //给数据赋值，用在数据维护页面
              this.tableDataValueEdit=result.data
            }
          }
        })
    },
    //修改数据的弹窗
    testingEdit(scope,doe){
      this.useDoe=doe
      //执行修改检测日期的操作
      if (doe===1){
        this.dialogVisibleDate=true
        this.testingEditUseId=scope.row.id
        this.titleUse='修改检测日期'
        this.tableIndex=scope.$index
      }
      //执行修改工件号的操作
      else if (doe===2){
        this.dialogVisibleName=true
        this.testingEditUseId=scope.row.id
        this.titleUse='修改检测工件号'
        this.tableIndex=scope.$index
      }
      else if (doe===3){
        this.dialogVisibleName=true
        this.testingEditUseId=scope.row.id
        this.titleUse='修改检测数据'
        this.tableIndex=scope.$index
      }
    },
    //修改数据，向后端传递的函数（文本日期类）
    saveJavaDate(idUse,field,val){
      //需要把数据处理，处理为yyyy-mm-dd格式的日期
      const date = new Date(val);
      const year = date.getFullYear().toString().padStart(4, '0');
      const month = (date.getMonth() + 1).toString().padStart(2, '0'); // 月份从0开始，所以需要+1
      const day = date.getDate().toString().padStart(2, '0');
      val=`${year}-${month}-${day}`

      this.$request.post('/testingEditStr',{idUse,field,val}).then(result=>{
        if (result.code === 401){
          this.$router.push('UserLogin')
          alert("您未登录，请登录")
        }else {
          alert("保存成功")
          if (this.tableIndex!==-1){
            //修改数据，修正页中的列表中的数据
            this.tableDataValueEdit[this.tableIndex][field]=val
            //修改数据，总表的数据
          }else {
            alert("程序有误，请联系管理员")
          }
        }
      })
    },
    //修改数据，向后端传递的函数（文本内容类）
    saveJava(idUse,field,val){
      this.$request.post('/testingEditStr',{idUse,field,val}).then(result=>{
        if (result.code === 401){
          this.$router.push('UserLogin')
          alert("您未登录，请登录")
        }else {
          alert("保存成功")
          if (this.tableIndex !== -1) {
            //修改数据，修正页中的列表中的数据
            this.tableDataValueEdit[this.tableIndex][field] = val
            //修改数据，总表的数据
          } else {
            alert("程序有误，请联系管理员")
          }
        }
      })
    },
    //修改数据，向后端传递的函数（数字内容类）
    saveJavaNmb(idUse,field,val){
        this.$request.post('/testingEditNmb',{idUse,field,val}).then(result=>{
          if (result.code === 401){
            this.$router.push('UserLogin')
            alert("您未登录，请登录")
          }else {
            alert("保存成功")
            if (this.tableIndex !== -1) {
              //修改数据，修正页中的列表中的数据
              this.tableDataValueEdit[this.tableIndex][field] = val
              //修改数据，总表的数据
            } else {
              alert("程序有误，请联系管理员")
            }
          }
        })
    },
    //点击弹窗，向后端传递数据进行修改
    saveTestingEdit(){
      if (this.useDoe===1){
        this.saveJavaDate(this.testingEditUseId,'testingDate',this.valueDate)
        this.dialogVisibleDate=false
      }
      else if (this.useDoe===2){
        this.saveJava(this.testingEditUseId,'workpiece',this.inputName)
        this.dialogVisibleName=false
      }
      else if (this.useDoe===3){
        //校验数据
        let regex = /^[-+]?\d*(\.\d+)?$/
        if (!regex.test(this.inputName)){
          alert("请输入数字")
        }else {
          this.saveJavaNmb(this.testingEditUseId,'valueUse',this.inputName)
          this.dialogVisibleName=false
        }
      }
    },
    //查询用户信息的函数
    inquiry(){
      //输入用户编号，向后端查询信息
      const useId=localStorage.getItem('userName').replace(/"/g, '');
      this.$request.post('/useQueryPower',{
        queryFiledName:'controlTesting',
        userId:useId,
      }).then(result=>{
        if (result.code === 401) {
          this.$router.push('UserLogin')
          alert("您未登录，请登录")
        }else {
          this.useName=result.data.name
          this.usePower=result.data.controlTesting
          this.useId=useId
          console.log(this.usePower)
        }
      })
    },
    //辅助函数：辅助做提示信息滚动的函数
    suggestAiRoll(){

    }
},
  mounted() {
    //调用用户权限
    this.inquiry()
    //用分装axios请求发送，并且带有头部信息
    this.$request.post("/controlTestingTreeList").then(result => {
      //判断，如果登录异常，跳转到登录页面
      if (result.code === 401) {
        this.$router.push('UserLogin')
        alert("您未登录，请登录")
      } else {
        // 画图用到的，画趋势图
        this.chartUser= echarts.init(this.$refs.myChart)
        this.chartUser.setOption(this.option);
        //画直方图
        this.chartUserBor=echarts.init(this.$refs.myChartBor)
        this.chartUserBor.setOption(this.optionBor)
        //画移动极差图
        this.chartUserLien=echarts.init(this.$refs.myChartLine)
        this.chartUserLien.setOption(this.optionLien)

        this.TreeListAll = result.data;
        if (this.languageS === "chinese") {
          this.TreeList = this.TreeListAll.slice(this.TreeListAll.length / 3, this.TreeListAll.length / 3 * 2)
        }
        this.parentLabel = 'no'
        this.ChildrenLabel = 'no'
      }
    })

  },
  beforeDestroy() {
    if (this.chartUser) {
      this.chartUser.dispose()
    }
    if (this.chartUserBor){
      this.chartUserBor.dispose()
    }
    if (this.chartUserLien){
      this.chartUserLien.dispose()
    }
  }
}
</script>

<style scoped>
/* 主体左侧的工作步骤栏用到的数据包围的div的样式*/

.el-footer {
  background-color: #ffffff;
  color: #333;
  text-align: center;
  border-width: 3px; /* 设置边框宽度为3像素 */
  border-color: blue; /* 设置边框颜色为蓝色 */
  border-style: solid; /* 设置边框样式为实线 */
  padding: 10px; /* 添加内边距 */
  border-left-color: white;
  border-top: white;
}

.el-aside {
  background-color: #ffffff;
  color: #333;
  text-align: center;
  border-width: 3px; /* 设置边框宽度为3像素 */
  border-color: blue; /* 设置边框颜色为蓝色 */
  border-style: solid; /* 设置边框样式为实线 */
  padding: 10px; /* 添加内边距 */
  height: 89vh;
}

.el-main {
  color: #333;
  text-align: center;
  border-width: 3px; /* 设置边框宽度为3像素 */
  border-color: blue; /* 设置边框颜色为蓝色 */
  border-left-color: white;
  border-style: solid; /* 设置边框样式为实线 */
  padding: 10px; /* 添加内边距 */
}


body > .el-container {
  margin-bottom: 40px;
}

.el-container:nth-child(5) .el-aside,
.el-container:nth-child(6) .el-aside {
  line-height: 260px;
}

.el-container:nth-child(7) .el-aside {
  line-height: 320px;
}

.item {
  flex: 1; /* 每个元素占据相等的空间 */
  /* 其他样式，如边框、背景色等 */
  box-sizing: border-box; /* 包括边框和内边距在计算宽度时 */
  margin: 10px;
  width: 100%;
}

.container {
  display: flex;
  justify-content: space-between; /* 让子元素分散在容器的两侧 */
  align-items: center; /* 垂直方向上居中对齐子元素 */
}

.UploadS{
  border-width: 1px; /* 设置边框宽度为3像素 */
  border-color: blue; /* 设置边框颜色为蓝色 */
  border-style: solid; /* 设置边框样式为虚线 */
  padding: 10px; /* 添加内边距 */
}
.UploadS1 {
  border-width: 1px; /* 设置边框宽度为3像素 */
  border-color: blue; /* 设置边框颜色为蓝色 */
  border-style: solid; /* 设置边框样式为虚线 */
  padding: 5px; /* 添加内边距 */
  margin: 5px;/* 添加内边距 */
  display: flex; /* 设置为 Flex 容器 */
  flex-direction: row; /* 子元素水平排列（默认就是这样） */
  justify-content: space-between; /* 两端对齐，如果需要平均分布使用space-around或space-evenly */
  height: 33vh;
}
.UploadS2 {
  border-width: 1px; /* 设置边框宽度为3像素 */
  border-color: blue; /* 设置边框颜色为蓝色 */
  border-style: solid; /* 设置边框样式为虚线 */
  padding: 5px; /* 添加内边距 */
  margin: 5px;/* 添加内边距 */
//display: flex; /* 启用Flexbox */
  justify-content: space-between; /* 两端对齐，如果需要平均分布使用space-around或space-evenly */
  height: 29vh;
  width: 55%;
}
.UploadS2-1 {
  border-width: 1px; /* 设置边框宽度为3像素 */
  border-color: red; /* 设置边框颜色为蓝色 */
  border-style: solid; /* 设置边框样式为虚线 */
  padding: 5px; /* 添加内边距 */
  margin: 5px;/* 添加内边距 */
//display: flex; /* 启用Flexbox */
  justify-content: space-between; /* 两端对齐，如果需要平均分布使用space-around或space-evenly */
  height: 29vh;
  width: 450px;
}
.UploadS2-2 {
  border-width: 1px; /* 设置边框宽度为3像素 */
  border-color: red; /* 设置边框颜色为蓝色 */
  border-style: solid; /* 设置边框样式为虚线 */
  padding: 5px; /* 添加内边距 */
  margin: 5px;/* 添加内边距 */
//display: flex; /* 启用Flexbox */
  justify-content: space-between; /* 两端对齐，如果需要平均分布使用space-around或space-evenly */
  height: 29vh;
  width: 350px;
  overflow-y: auto;
}
.UploadContainer {
  display: flex;
  flex-direction: column; /* 设置为列方向 */
  width: 100%;
}
.UploadRow {
  display: flex;
  justify-content: space-between; /* 两端对齐，使子元素左右平分 */
  margin-top: 3px; /* 添加上外边距，与第一个元素区分 */
}
.button{
  width: 160px;
}
.UploadS3 {
  flex: 1; /* 每个子元素占据可用空间的相等部分 */
  /* 或者，如果你想要明确设置宽度为 50% */
   height: 100%;
  box-sizing: border-box; /* 确保边框和内边距包含在元素的宽度内 */
  /* 其他样式 ... */
}

.headMain{
  color: #ffffff; /* 设置字体颜色为红色 */
  font-size: 18px;
}
.center-text {
  /* 使用 margin-left 和 margin-right auto 来实现居中效果 */
  margin-left: auto;
  margin-right: auto;
  /* 注意：如果 header 内只有这两个元素，你可能不需要 margin-right: auto */
}

.LineDiv{
  width:75vw;
  height: 34vh;
  margin-left: 0;
}

</style>